<template>
  <Dialog :title="dialogTitle" v-model="dialogVisible" width="1200px">
    <el-form
      ref="formRef"
      :model="formData"
      :rules="formRules"
      label-width="120px"
      v-loading="formLoading"
    >
      <!-- 订单基本信息 -->
      <el-divider content-position="left">
        <span class="text-16px font-bold">订单基本信息</span>
      </el-divider>

      <el-row :gutter="20">
        <el-col :span="8">
          <el-form-item label="配送农场" prop="farmId">
            <el-input
              v-model="formData.farmName"
              placeholder="请点击选择农场"
              readonly
              class="w-full"
              @click="handleSelectFarm"
              style="cursor: pointer"
            >
              <template #prefix>
                <el-icon><Location /></el-icon>
              </template>
              <template #suffix>
                <el-icon class="cursor-pointer">
                  <Search />
                </el-icon>
              </template>
            </el-input>
          </el-form-item>
        </el-col>
        <el-col :span="8">
          <el-form-item label="预计到货时间" prop="estimatedArrivalTime">
            <el-date-picker
              v-model="formData.estimatedArrivalTime"
              type="datetime"
              value-format="x"
              placeholder="选择预计到货时间"
              class="w-full"
            />
          </el-form-item>
        </el-col>
      </el-row>

      <el-row :gutter="20">
        <el-col :span="8">
          <el-form-item label="车牌号" prop="vehiclePlate">
            <el-input v-model="formData.vehiclePlate" placeholder="请输入车牌号" clearable />
          </el-form-item>
        </el-col>
        <el-col :span="8">
          <el-form-item label="物流公司" prop="logisticsCompany">
            <el-input v-model="formData.logisticsCompany" placeholder="请输入物流公司" clearable />
          </el-form-item>
        </el-col>
        <el-col :span="8">
          <el-form-item label="物流单号" prop="logisticsNo">
            <el-input v-model="formData.logisticsNo" placeholder="请输入物流单号" clearable />
          </el-form-item>
        </el-col>
      </el-row>

      <el-row :gutter="20" v-if="formType === 'create'">
        <el-col :span="24">
          <el-form-item label=" " label-width="120px">
            <el-button
              type="primary"
              plain
              :loading="loadingLogisticsInfo"
              @click="handleGetLogisticsInfo"
            >
              <el-icon class="mr-5px"><Van /></el-icon>
              获取物流信息
            </el-button>
            <span class="text-gray-400 text-12px ml-10px">
              点击自动填充物流公司、物流单号、车牌号等信息
            </span>
          </el-form-item>
        </el-col>
      </el-row>

      <el-row :gutter="20">
        <el-col :span="24">
          <el-form-item label="备注信息" prop="remark">
            <el-input
              v-model="formData.remark"
              type="textarea"
              :rows="2"
              placeholder="请输入备注信息"
            />
          </el-form-item>
        </el-col>
      </el-row>

      <!-- 配送明细 -->
      <el-divider content-position="left">
        <span class="text-16px font-bold">配送明细（可配送到多个基地）</span>
      </el-divider>

      <el-button type="primary" :icon="Plus" @click="handleAddItem" class="mb-15px">
        添加配送明细
      </el-button>

      <el-table :data="formData.items" border class="mb-15px" :max-height="500">
        <el-table-column type="index" label="序号" width="60" align="center" />

        <!-- 配送基地 -->
        <el-table-column label="配送基地" min-width="180" align="center">
          <template #default="{ row }">
            <el-select
              v-model="row.baseId"
              placeholder="请选择基地"
              filterable
              clearable
              @change="handleBaseChangeInRow(row)"
            >
              <el-option
                v-for="base in baseList"
                :key="base.id"
                :label="base.baseName"
                :value="base.id"
              />
            </el-select>
          </template>
        </el-table-column>

        <!-- 配送商品（多选） -->
        <el-table-column label="配送商品（可多选）" min-width="250" align="center">
          <template #default="{ row }">
            <el-select
              v-model="row.productIds"
              placeholder="请先选择基地"
              filterable
              clearable
              multiple
              collapse-tags
              collapse-tags-tooltip
              :max-collapse-tags="2"
              :disabled="!row.baseId"
              @change="handleProductsChange(row)"
            >
              <el-option
                v-for="product in row.productList || []"
                :key="product.id"
                :label="product.name"
                :value="product.id"
                :disabled="!product.stock || product.stock <= 0"
              >
                <div class="flex items-center justify-between w-full">
                  <span class="truncate flex-1 min-w-0">{{ product.name }}</span>
                  <div class="flex items-center ml-10px" style="flex-shrink: 0">
                    <span class="text-gray-400 text-12px mr-10px">
                      ¥{{ (product.price / 100).toFixed(2) }}/{{ product.unit }}
                    </span>
                    <span
                      :class="[
                        'text-12px',
                        !product.stock || product.stock <= 0
                          ? 'text-red-500'
                          : product.stock <= 10
                            ? 'text-orange-500'
                            : 'text-green-500'
                      ]"
                    >
                      库存: {{ product.stock || 0 }}
                    </span>
                  </div>
                </div>
              </el-option>
            </el-select>
          </template>
        </el-table-column>

        <!-- 商品明细（展开显示每个商品的数量和价格） -->
        <el-table-column label="商品明细" min-width="350" align="center">
          <template #default="{ row }">
            <div v-if="row.products && row.products.length > 0" class="product-details">
              <div v-for="(product, idx) in row.products" :key="idx" class="product-item">
                <div class="product-info">
                  <span class="product-name">{{ product.name }}</span>
                  <div class="product-inputs">
                    <el-input-number
                      v-model="product.unitPrice"
                      :precision="2"
                      :min="0"
                      :controls="false"
                      size="small"
                      placeholder="单价"
                      class="price-input"
                      @change="handleProductDetailChange(row)"
                    />
                    <span class="mx-5px">×</span>
                    <el-input-number
                      v-model="product.quantity"
                      :min="0"
                      :max="product.stock || 0"
                      :controls="true"
                      size="small"
                      placeholder="数量"
                      class="quantity-input"
                      @change="handleQuantityChange(row, product)"
                    />
                    <span class="ml-5px text-12px text-gray-400">
                      (库存: {{ product.stock || 0 }})
                    </span>
                    <span class="ml-10px text-red-500 font-bold">
                      = ¥{{ ((product.unitPrice || 0) * (product.quantity || 0)).toFixed(2) }}
                    </span>
                  </div>
                </div>
              </div>
              <div class="row-total">
                本行小计:
                <span class="text-red-500 font-bold text-16px"
                  >¥{{ row.totalPrice.toFixed(2) }}</span
                >
              </div>
            </div>
            <div v-else class="text-gray-400"> 请选择商品 </div>
          </template>
        </el-table-column>

        <!-- 质量备注 -->
        <el-table-column label="整体备注" min-width="150" align="center">
          <template #default="{ row }">
            <el-input
              v-model="row.qualityRemark"
              type="textarea"
              :rows="2"
              placeholder="该基地的整体备注"
              clearable
            />
          </template>
        </el-table-column>

        <!-- 操作 -->
        <el-table-column label="操作" width="80" align="center" fixed="right">
          <template #default="{ $index }">
            <el-button link type="danger" :icon="Delete" @click="handleDeleteItem($index)">
              删除
            </el-button>
          </template>
        </el-table-column>
      </el-table>

      <!-- 合计信息 -->
      <div class="flex justify-end items-center text-16px mb-10px">
        <span class="mr-20px">
          涉及基地: <span class="text-blue-500 font-bold">{{ baseCount }}</span> 个
        </span>
        <span class="mr-20px">
          总数量: <span class="text-blue-500 font-bold">{{ totalQuantity }}</span>
        </span>
        <span>
          配送总价: <span class="text-red-500 font-bold text-18px">¥{{ totalPrice }}</span>
        </span>
      </div>
    </el-form>

    <template #footer>
      <el-button @click="dialogVisible = false">取 消</el-button>
      <el-button type="primary" @click="submitForm" :disabled="formLoading"> 确 定 </el-button>
    </template>
  </Dialog>

  <!-- 农场选择弹框 -->
  <FarmSelectDialog ref="farmSelectDialogRef" @confirm="handleFarmSelected" />
</template>

<script setup lang="ts">
import { Plus, Delete, Location, Van, Search } from '@element-plus/icons-vue'
import { OrderApi, OrderVO } from '@/api/mall/trade/deliveryOrder'
import { getSpuSimpleListByFarm } from '@/api/mall/product/spu'
import { DistributionBaseApi } from '@/api/system/distribution/base/index'
import { InfoVO, InfoApi } from '@/api/farm/info'
import FarmSelectDialog from '@/views/farm/product/spu/form/FarmSelectDialog.vue'

/** 农场到自营门店的配送订单 表单 */
defineOptions({ name: 'OrderForm' })

const { t } = useI18n() // 国际化
const message = useMessage() // 消息弹窗

const dialogVisible = ref(false) // 弹窗的是否展示
const dialogTitle = ref('') // 弹窗的标题
const formLoading = ref(false) // 表单的加载中
const formType = ref('') // 表单的类型：create - 新增；update - 修改
const loadingLogisticsInfo = ref(false) // 获取物流信息的加载状态
const farmSelectDialogRef = ref() // 农场选择弹框引用

// 商品明细
interface ProductDetail {
  detailId?: number // 明细项的ID（编辑时后端返回的明细ID）
  productId: number // 商品ID
  name: string
  unitPrice: number
  quantity: number
  stock?: number // 库存数量
}

// 表单数据结构（包含明细）
interface OrderItem {
  id?: number
  baseId?: number // 基地ID
  baseName?: string // 基地名称
  productIds?: number[] // 选中的商品ID列表（多选）
  products?: ProductDetail[] // 商品明细列表
  totalPrice: number // 本行小计
  qualityRemark?: string // 质量备注
  productList?: any[] // 该行可选的商品列表
}

const formData = ref<any>({
  id: undefined,
  orderNo: undefined,
  farmId: undefined,
  farmName: undefined, // 农场名称（只读显示）
  status: undefined, // 配送状态
  totalPrice: 0,
  vehiclePlate: undefined,
  logisticsCompany: undefined,
  logisticsNo: undefined,
  estimatedArrivalTime: undefined,
  remark: undefined,
  items: [] as OrderItem[] // 配送明细列表
})

// 表单校验规则
const formRules = reactive({
  farmId: [{ required: true, message: '请选择配送基地', trigger: 'change' }],
  status: [{ required: true, message: '请选择配送状态', trigger: 'change' }],
  estimatedArrivalTime: [{ required: true, message: '请选择预计到货时间', trigger: 'change' }]
})

const formRef = ref() // 表单 Ref

// 下拉列表数据
const baseList = ref<any[]>([]) // 基地列表

/** 计算涉及的基地数量 */
const baseCount = computed(() => {
  const baseIds = new Set(
    formData.value.items.filter((item) => item.baseId).map((item) => item.baseId)
  )
  return baseIds.size
})

/** 计算总数量 */
const totalQuantity = computed(() => {
  return formData.value.items.reduce((sum, item) => {
    const itemQuantity = (item.products || []).reduce(
      (qSum, product) => qSum + (product.quantity || 0),
      0
    )
    return sum + itemQuantity
  }, 0)
})

/** 计算总价 */
const totalPrice = computed(() => {
  const total = formData.value.items.reduce((sum, item) => sum + (item.totalPrice || 0), 0)
  return total.toFixed(2)
})

/** 在表格行中选择基地时的处理 */
const handleBaseChangeInRow = async (row: OrderItem) => {
  if (!row.baseId) {
    // 清空基地时，清空商品相关信息
    row.productIds = []
    row.products = []
    row.totalPrice = 0
    row.productList = []
  } else {
    // 检查是否已选择农场
    if (!formData.value.farmId) {
      message.warning('请先选择配送农场')
      row.baseId = undefined
      return
    }

    // 加载该农场的商品列表
    await loadProductListForRow(row)
    // 清空之前选择的商品（因为基地变了）
    row.productIds = []
    row.products = []
    row.totalPrice = 0

    // 更新基地名称
    const base = baseList.value.find((b) => b.id === row.baseId)
    if (base) {
      row.baseName = base.baseName
    }
  }
}

/** 为某一行加载商品列表（根据农场ID获取） */
const loadProductListForRow = async (row: OrderItem) => {
  try {
    if (!formData.value.farmId) {
      console.warn('农场ID不存在，无法加载商品列表')
      row.productList = []
      return
    }
    // 根据农场ID获取该农场的商品列表（SPU）
    const spuList = await getSpuSimpleListByFarm(formData.value.farmId)

    // 展开 SPU 为可选的商品项（SKU 或 SPU）
    const productList: any[] = []

    if (spuList && spuList.length > 0) {
      spuList.forEach((spu) => {
        // 只处理有 SKU 列表的商品，没有 SKU 的商品不展示（可能是测试错误数据）
        if (spu.skus && Array.isArray(spu.skus) && spu.skus.length > 0) {
          spu.skus.forEach((sku) => {
            // 构建 SKU 显示名称：SPU名称 - SKU名称
            const spuName = spu.name // SPU 名称
            let skuName = '' // SKU 名称

            // 优先使用 SKU 的 name 字段
            if (sku.name && sku.name.trim()) {
              skuName = sku.name.trim()
            }
            // 如果 SKU 没有 name，则从 properties 提取规格组合
            else if (sku.properties && sku.properties.length > 0) {
              const specs = sku.properties
                .map((p) => p.valueName || '')
                .filter((v) => v && v !== '默认')
                .join('/')

              if (specs) {
                skuName = specs
              } else {
                skuName = '默认'
              }
            } else {
              skuName = '默认'
            }

            // 组合完整名称：SPU名称 - SKU名称
            const fullName = skuName === '默认' ? spuName : `${spuName} - ${skuName}`

            productList.push({
              id: sku.id, // SKU ID
              spuId: spu.id, // SPU ID
              spuName: spuName, // SPU 名称（单独保存）
              skuName: skuName, // SKU 名称（单独保存）
              name: fullName, // 完整显示名称（SPU名称 - SKU名称）
              price: typeof sku.price === 'number' ? sku.price : 0, // 价格（分）
              stock: sku.stock || 0,
              unit: spu.unit || '件',
              type: 'sku', // 标记为 SKU
              picUrl: sku.picUrl || spu.picUrl
            })
          })
        }
        // 没有 SKU 的商品直接跳过，不添加到列表中
      })
    }

    row.productList = productList
    console.log('加载的商品列表:', productList)
  } catch (error) {
    console.error('加载商品列表失败:', error)
    message.error('加载商品列表失败，请重试')
    row.productList = []
  }
}

/** 打开农场选择弹框 */
const handleSelectFarm = () => {
  farmSelectDialogRef.value?.open()
}

/** 农场选择确认回调 */
const handleFarmSelected = (farm: InfoVO) => {
  formData.value.farmId = farm.id
  formData.value.farmName = farm.farmName

  // 清空已有的配送明细（因为农场变了，商品列表会不同）
  if (formData.value.items && formData.value.items.length > 0) {
    message.warning('切换农场后，原有配送明细已清空，请重新添加')
    formData.value.items = []
  }
}

/** 加载基地列表 */
const loadBaseList = async () => {
  try {
    const data = await DistributionBaseApi.getSimpleBaseList()
    baseList.value = data || []
  } catch (error) {
    console.error('加载基地列表失败:', error)
    baseList.value = []
  }
}

/** 添加配送明细行 */
const handleAddItem = () => {
  // 检查是否已选择农场
  if (!formData.value.farmId) {
    message.warning('请先选择配送农场')
    return
  }

  formData.value.items.push({
    baseId: undefined,
    baseName: undefined,
    productIds: [],
    products: [],
    totalPrice: 0,
    qualityRemark: undefined,
    productList: []
  })
}

/** 删除配送明细行 */
const handleDeleteItem = (index: number) => {
  formData.value.items.splice(index, 1)
}

/** 多选商品变化时的处理 */
const handleProductsChange = (row: OrderItem) => {
  if (!row.productIds || row.productIds.length === 0) {
    row.products = []
    row.totalPrice = 0
    return
  }

  // 获取新选择的商品
  const newProductIds = row.productIds
  const oldProducts = row.products || []
  const newProducts: ProductDetail[] = []

  // 保留已有的商品数据，添加新选择的商品
  newProductIds.forEach((productId) => {
    const existingProduct = oldProducts.find((p) => p.productId === productId)

    if (existingProduct) {
      // 保留已有的数量和价格，同步更新库存信息
      const productInfo = row.productList?.find((p) => p.id === productId)
      if (productInfo) {
        existingProduct.stock = productInfo.stock || 0
        // 同步更新价格（如果商品信息中的价格有变化）
        existingProduct.unitPrice = (productInfo.price || 0) / 100
      }
      newProducts.push(existingProduct)
    } else {
      // 新添加的商品
      const productInfo = row.productList?.find((p) => p.id === productId)
      if (productInfo) {
        // 检查库存
        const stock = productInfo.stock || 0
        if (stock <= 0) {
          message.warning(`商品"${productInfo.name}"库存不足，无法添加`)
          return
        }

        newProducts.push({
          productId: productInfo.id,
          name: productInfo.name,
          unitPrice: (productInfo.price || 0) / 100, // 将分转换为元
          quantity: 1, // 默认数量为1
          stock: stock
        })
      }
    }
  })

  row.products = newProducts
  handleProductDetailChange(row)
}

/** 商品明细数量或价格变化时重新计算 */
const handleProductDetailChange = (row: OrderItem) => {
  if (!row.products || row.products.length === 0) {
    row.totalPrice = 0
    return
  }

  // 计算本行所有商品的小计之和
  row.totalPrice = row.products.reduce((sum, product) => {
    return sum + (product.unitPrice || 0) * (product.quantity || 0)
  }, 0)
}

/** 商品数量变化时的处理 - 添加库存校验 */
const handleQuantityChange = (row: OrderItem, product: ProductDetail) => {
  const stock = product.stock || 0
  const quantity = product.quantity || 0

  // 检查是否超过库存
  if (quantity > stock) {
    message.warning(`商品"${product.name}"的配送数量不能超过库存数量(${stock})`)
    // 将数量调整为库存数量
    product.quantity = stock
  }

  // 重新计算金额
  handleProductDetailChange(row)
}

/** 获取物流信息（暂时使用虚拟数据） */
const handleGetLogisticsInfo = async () => {
  loadingLogisticsInfo.value = true

  try {
    // TODO: 后续对接第三方物流接口
    // const logisticsData = await ThirdPartyLogisticsApi.getLogisticsInfo()

    // 暂时使用虚拟数据模拟接口返回
    await new Promise((resolve) => setTimeout(resolve, 1000)) // 模拟网络延迟

    // 生成虚拟物流数据
    const mockLogisticsData = {
      vehiclePlate: generateVehiclePlate(),
      logisticsCompany: getRandomLogisticsCompany(),
      logisticsNo: generateLogisticsNo()
    }

    // 填充到表单
    formData.value.vehiclePlate = mockLogisticsData.vehiclePlate
    formData.value.logisticsCompany = mockLogisticsData.logisticsCompany
    formData.value.logisticsNo = mockLogisticsData.logisticsNo

    message.success('物流信息获取成功')
  } catch (error) {
    console.error('获取物流信息失败:', error)
    message.error('获取物流信息失败，请稍后重试')
  } finally {
    loadingLogisticsInfo.value = false
  }
}

/** 生成虚拟车牌号 */
const generateVehiclePlate = (): string => {
  const provinces = [
    '京',
    '沪',
    '津',
    '渝',
    '冀',
    '豫',
    '云',
    '辽',
    '黑',
    '湘',
    '皖',
    '鲁',
    '苏',
    '浙',
    '赣',
    '鄂',
    '甘',
    '晋',
    '陕',
    '吉',
    '闽',
    '贵',
    '粤',
    '青',
    '藏',
    '川',
    '宁',
    '琼',
    '新'
  ]
  const letters = 'ABCDEFGHJKLMNPQRSTUVWXYZ'
  const numbers = '0123456789'

  const province = provinces[Math.floor(Math.random() * provinces.length)]
  const letter = letters[Math.floor(Math.random() * letters.length)]

  let plateNumber = province + letter
  for (let i = 0; i < 5; i++) {
    if (Math.random() > 0.3) {
      plateNumber += numbers[Math.floor(Math.random() * numbers.length)]
    } else {
      plateNumber += letters[Math.floor(Math.random() * letters.length)]
    }
  }

  return plateNumber
}

/** 获取随机物流公司 */
const getRandomLogisticsCompany = (): string => {
  const companies = [
    '顺丰速运',
    '中通快递',
    '圆通速递',
    '申通快递',
    '韵达快递',
    '百世快递',
    '德邦物流',
    '京东物流',
    '菜鸟物流',
    '极兔速递'
  ]
  return companies[Math.floor(Math.random() * companies.length)]
}

/** 生成虚拟物流单号 */
const generateLogisticsNo = (): string => {
  const prefix = ['SF', 'ZT', 'YT', 'ST', 'YD', 'BS', 'DB', 'JD'][Math.floor(Math.random() * 8)]
  let number = ''
  for (let i = 0; i < 12; i++) {
    number += Math.floor(Math.random() * 10)
  }
  return prefix + number
}

/** 打开弹窗 */
const open = async (type: string, id?: number) => {
  dialogVisible.value = true
  dialogTitle.value = type === 'create' ? '新增配送订单' : '编辑配送订单'
  formType.value = type
  resetForm()

  // 加载基础数据
  formLoading.value = true
  try {
    // 加载基地列表
    await loadBaseList()

    // 修改时，设置数据
    if (id) {
      const data = await OrderApi.getOrder(id)

      // 如果后端没有返回农场名称，根据farmId查询农场信息来填充
      let farmName = data.farmName
      if (!farmName && data.farmId) {
        try {
          const farmList = await InfoApi.getSimpleFarmList()
          const farm = farmList.find((f) => f.id === data.farmId)
          if (farm) {
            farmName = farm.farmName
          }
        } catch (error) {
          console.error('查询农场信息失败:', error)
        }
      }

      // 将后端返回的扁平数据转换为前端的分组格式
      // 后端：一条记录 = 一个基地 + 一个商品
      // 前端：一行 = 一个基地 + 多个商品
      const groupedItems: OrderItem[] = []
      if (data.items && data.items.length > 0) {
        const baseMap = new Map<number, OrderItem>()

        for (const item of data.items) {
          if (!baseMap.has(item.baseId)) {
            // 创建新的基地分组
            const newItem: OrderItem = {
              baseId: item.baseId,
              baseName: item.baseName,
              productIds: [],
              products: [],
              totalPrice: 0,
              qualityRemark: item.qualityRemark,
              productList: []
            }
            baseMap.set(item.baseId, newItem)
            groupedItems.push(newItem)

            // 加载该基地的商品列表
            await loadProductListForRow(newItem)
          }

          const baseItem = baseMap.get(item.baseId)!
          // 从商品列表中获取库存信息
          const productInfo = baseItem.productList?.find((p) => p.id === item.productId)
          // 添加商品明细
          baseItem.productIds!.push(item.productId)
          baseItem.products!.push({
            detailId: item.id, // 保存明细项的ID，用于修改时提交
            productId: item.productId,
            name: item.productName,
            unitPrice: item.unitPrice, // 后端返回的已经是元
            quantity: item.quantity,
            stock: productInfo?.stock || 0
          })
        }

        // 计算每一行的小计
        groupedItems.forEach((item) => {
          handleProductDetailChange(item)
        })
      }

      // 设置表单数据
      formData.value = {
        id: data.id,
        orderNo: data.orderNo,
        farmId: data.farmId,
        farmName: farmName, // 使用查询到的农场名称
        status: data.status,
        totalPrice: data.totalPrice,
        vehiclePlate: data.vehiclePlate,
        logisticsCompany: data.logisticsCompany,
        logisticsNo: data.logisticsNo,
        estimatedArrivalTime: data.estimatedArrivalTime,
        remark: data.remark,
        items: groupedItems
      }
    }
  } finally {
    formLoading.value = false
  }
}
defineExpose({ open }) // 提供 open 方法，用于打开弹窗

/** 提交表单 */
const emit = defineEmits(['success']) // 定义 success 事件，用于操作成功后的回调
const submitForm = async () => {
  // 校验表单
  await formRef.value.validate()

  // 校验明细
  if (formData.value.items.length === 0) {
    message.warning('请至少添加一条配送明细')
    return
  }

  // 校验明细中的基地、商品和数量
  for (let i = 0; i < formData.value.items.length; i++) {
    const item = formData.value.items[i]
    if (!item.baseId) {
      message.warning(`第 ${i + 1} 行：请选择配送基地`)
      return
    }
    if (!item.productIds || item.productIds.length === 0) {
      message.warning(`第 ${i + 1} 行：请至少选择一个配送商品`)
      return
    }
    if (!item.products || item.products.length === 0) {
      message.warning(`第 ${i + 1} 行：商品明细数据异常`)
      return
    }
    // 检查每个商品的数量和库存
    for (let j = 0; j < item.products.length; j++) {
      const product = item.products[j]
      if (!product.quantity || product.quantity <= 0) {
        message.warning(`第 ${i + 1} 行的商品"${product.name}"：请输入正确的数量`)
        return
      }
      // 验证库存
      const stock = product.stock || 0
      if (product.quantity > stock) {
        message.warning(
          `第 ${i + 1} 行的商品"${product.name}"：配送数量(${product.quantity})不能超过库存数量(${stock})`
        )
        return
      }
    }
  }

  // 提交请求
  formLoading.value = true
  try {
    // 更新总价
    formData.value.totalPrice = parseFloat(totalPrice.value)

    // 转换数据格式：将前端的分组结构转换为后端期望的扁平结构
    // 前端：一行 = 一个基地 + 多个商品
    // 后端：一行 = 一个基地 + 一个商品
    const backendItems: any[] = []
    formData.value.items.forEach((item) => {
      // 将该基地的每个商品展开成一条记录
      if (item.products && item.products.length > 0) {
        item.products.forEach((product) => {
          const detailItem: any = {
            baseId: item.baseId,
            baseName: item.baseName,
            productId: product.productId,
            productName: product.name,
            unitPrice: product.unitPrice,
            quantity: product.quantity,
            totalPrice: (product.unitPrice || 0) * (product.quantity || 0),
            qualityRemark: item.qualityRemark || ''
          }

          // 只有在修改模式且明细项有 detailId 时才传 id（表示是原有明细）
          // 新增模式或新添加的明细项不传 id
          if (formType.value === 'update' && product.detailId) {
            detailItem.id = product.detailId
          }

          backendItems.push(detailItem)
        })
      }
    })

    // 构造后端期望的数据格式
    const data: OrderVO = {
      id: formData.value.id,
      farmId: formData.value.farmId,
      status: formData.value.status,
      vehiclePlate: formData.value.vehiclePlate,
      logisticsCompany: formData.value.logisticsCompany,
      logisticsNo: formData.value.logisticsNo,
      estimatedArrivalTime: formData.value.estimatedArrivalTime,
      remark: formData.value.remark,
      totalPrice: formData.value.totalPrice,
      items: backendItems
    } as OrderVO

    if (formType.value === 'create') {
      await OrderApi.createOrder(data)
      message.success(t('common.createSuccess'))
    } else {
      await OrderApi.updateOrder(data)
      message.success(t('common.updateSuccess'))
    }
    dialogVisible.value = false
    // 发送操作成功的事件
    emit('success')
  } finally {
    formLoading.value = false
  }
}

/** 重置表单 */
const resetForm = () => {
  formData.value = {
    id: undefined,
    orderNo: undefined,
    farmId: undefined,
    farmName: undefined,
    status: undefined,
    totalPrice: 0,
    vehiclePlate: undefined,
    logisticsCompany: undefined,
    logisticsNo: undefined,
    estimatedArrivalTime: undefined,
    remark: undefined,
    items: []
  }
  formRef.value?.resetFields()
}
</script>

<style scoped lang="scss">
:deep(.el-input-number) {
  width: 100%;
}

:deep(.el-select) {
  width: 100%;
}

// 商品明细样式
.product-details {
  padding: 10px;
  text-align: left;

  .product-item {
    padding: 8px 0;
    border-bottom: 1px dashed #e5e7eb;

    &:last-child {
      border-bottom: none;
    }

    .product-info {
      display: flex;
      flex-direction: column;
      gap: 8px;

      .product-name {
        font-size: 14px;
        font-weight: 500;
        color: #303133;
      }

      .product-inputs {
        display: flex;
        align-items: center;
        gap: 5px;

        .price-input {
          width: 100px;
        }

        .quantity-input {
          width: 120px;
        }
      }
    }
  }

  .row-total {
    padding-top: 10px;
    margin-top: 12px;
    font-size: 14px;
    font-weight: 500;
    text-align: right;
    border-top: 2px solid #e5e7eb;
  }
}
</style>
